/**
 * 日本旅行实用英语指南 - 音频管理器
 * 
 * 这个脚本负责管理所有音频文件的加载和播放功能
 * 实现了延迟加载、预缓存和用户交互反馈
 */

// 音频管理器类
class AudioManager {
    constructor() {
        this.audioCache = {}; // 用于缓存已加载的音频
        this.currentCategory = null; // 当前场景类别
        this.isLoading = false; // 加载状态标记
    }
    
    // 加载特定场景的所有音频
    loadCategoryAudios(category) {
        if (this.currentCategory === category || this.isLoading) return;
        
        this.currentCategory = category;
        this.isLoading = true;
        
        // 获取该场景下所有音频按钮
        const audioButtons = document.querySelectorAll(`#${category} .audio-btn`);
        
        audioButtons.forEach(btn => {
            const audioId = btn.getAttribute('data-audio-id');
            if (audioId) {
                this.preloadAudio(audioId);
            }
        });
        
        this.isLoading = false;
        console.log(`已预加载 ${category} 场景的音频文件`);
    }
    
    // 加载音频文件，支持主要和备用音频源
    preloadAudio(audioId, phraseText = null, useFallback = false) {
        // 如果已缓存且不是使用备用源，则直接返回
        if (this.audioCache[audioId] && !useFallback) return;
        
        // 优先使用 phraseText，否则使用 audioId (替换连字符)
        const textToSpeak = phraseText || audioId.replace(/-/g, ' ');
        let audioUrl;
        
        if (!useFallback) {
            // 主要API - 使用有道词典API
            const timestamp = new Date().getTime();
            audioUrl = `https://dict.youdao.com/dictvoice?audio=${encodeURIComponent(textToSpeak)}&type=2&_=${timestamp}`;
        } else {
            // 备用API - 使用Google翻译TTS API
            audioUrl = `https://translate.google.com/translate_tts?ie=UTF-8&q=${encodeURIComponent(textToSpeak)}&tl=en&client=tw-ob`;
        }
        
        const audio = new Audio(audioUrl);
        audio.load();
        this.audioCache[audioId] = audio;
        
        // 添加错误处理
        audio.addEventListener('error', (e) => {
            if (!useFallback) {
                // 主要API失败，尝试备用API
                console.warn(`音频 ${audioId} 加载失败，尝试使用备用API: ${e.message}`);
                this.preloadAudio(audioId, textToSpeak, true);
            } else {
                // 备用API也失败
                console.error(`备用音频 ${audioId} 加载也失败了: ${e.message}`);
                // 创建一个空的音频对象，防止后续播放时出错
                this.audioCache[audioId] = new Audio();
            }
        });
    }
    
    // 尝试使用备用音频源 (保留此方法以兼容现有代码)
    tryFallbackAudio(audioId, phraseText = null) {
        this.preloadAudio(audioId, phraseText, true);
    }
    
    // 播放音频
    playAudio(audioId) {
        const button = document.querySelector(`[data-audio-id="${audioId}"]`);
        const phraseText = button ? button.getAttribute('data-phrase-text') : null;

        // 如果未缓存，先加载
        if (!this.audioCache[audioId]) {
            this.preloadAudio(audioId, phraseText);
        }
        
        // 获取音频对象
        const audio = this.audioCache[audioId];
        if (!audio) {
            return Promise.reject(new Error(`Audio object not found for ${audioId}`));
        }
        
        // 重置播放位置
        audio.currentTime = 0;
        
        // 统一使用Promise处理播放
        return new Promise((resolve, reject) => {
            // 播放成功的处理函数
            const onPlaySuccess = () => resolve(true);
            
            // 播放错误的处理函数
            const onPlayError = (err) => {
                console.error(`播放错误: ${err.message}`);
                reject(err);
            };
            
            // 尝试播放
            audio.play().then(onPlaySuccess).catch(onPlayError);
        });
    }
    
    // 暂停所有音频
    pauseAll() {
        Object.values(this.audioCache).forEach(audio => {
            if (!audio.paused) {
                audio.pause();
            }
        });
    }
    
    // 释放不再需要的音频资源（可在切换大的场景时调用）
    releaseUnusedAudios(exceptCategory) {
        const keysToDelete = [];
        
        Object.keys(this.audioCache).forEach(key => {
            // 检查此音频是否属于当前需要保留的类别
            const shouldKeep = document.querySelector(`#${exceptCategory} [data-audio-id="${key}"]`);
            
            if (!shouldKeep) {
                // 停止播放
                this.audioCache[key].pause();
                // 释放资源
                this.audioCache[key].src = '';
                // 标记为删除
                keysToDelete.push(key);
            }
        });
        
        // 从缓存中删除不需要的音频
        keysToDelete.forEach(key => {
            delete this.audioCache[key];
        });
        
        console.log(`已释放 ${keysToDelete.length} 个不需要的音频资源`);
    }
}

// 初始化全局音频管理器
const audioManager = new AudioManager();

/**
 * Player类用于播放音频，支持多种音频源和错误处理
 */
class Player {
    constructor() {
        this.url = "";
        this.audio = new Audio();
        this.fallbackAttempted = false;
    }
    
    play() {
        // 添加错误处理和加载事件
        return new Promise((resolve, reject) => {
            // 清除之前的事件监听器
            this.audio.oncanplaythrough = null;
            this.audio.onerror = null;
            
            // 统一处理播放错误的函数
            const handlePlayError = (err) => {
                if (!this.fallbackAttempted) {
                    this.fallbackAttempted = true;
                    console.log("尝试使用备用音频源");
                    this.tryFallback().then(resolve).catch(reject);
                } else {
                    reject(err || new Error("所有音频源都加载失败"));
                }
            };
            
            // 设置加载完成事件
            this.audio.oncanplaythrough = () => {
                // 播放音频
                this.audio.play()
                    .then(resolve)
                    .catch(handlePlayError);
            };
            
            // 设置错误处理
            this.audio.onerror = (e) => {
                console.error(`音频加载失败: ${this.url}`);
                handlePlayError(e);
            };
            
            // 设置音频源并开始加载
            this.audio.src = this.url;
            this.audio.load();
        });
    }
    
    // 尝试使用备用音频源
    tryFallback() {
        // 从当前URL中提取短语ID
        let phraseId = this.extractPhraseId();
        
        if (!phraseId) {
            return Promise.reject(new Error("无法提取短语ID"));
        }
        
        // 使用另一个备用API
        this.url = `https://fanyi.baidu.com/gettts?lan=en&text=${encodeURIComponent(phraseId)}&spd=3&source=web`;
        this.audio = new Audio(this.url);
        return this.audio.play();
    }
    
    // 从URL中提取短语ID
    extractPhraseId() {
        if (!this.url) return "";
        
        try {
            if (this.url.includes("dict.youdao.com")) {
                const urlParams = new URLSearchParams(this.url.split("?")[1]);
                return urlParams.get("audio");
            } else if (this.url.includes("translate.google.com")) {
                const urlParams = new URLSearchParams(this.url.split("?")[1]);
                return urlParams.get("q");
            }
        } catch (err) {
            console.error("提取短语ID时出错:", err);
        }
        
        return "";
    }
}

/**
 * 播放音频并显示播放反馈效果
 */
function playAudio(phraseId) {
    // 获取当前按钮
    const btn = event.currentTarget;
    const originalContent = btn.innerHTML;
    
    // 添加播放效果
    updateButtonState(btn, true, originalContent);
    
    // 使用AudioManager类播放音频（优先使用缓存和错误处理机制）
    audioManager.playAudio(phraseId)
        .then(success => {
            if (!success) {
                // 如果AudioManager播放失败，尝试使用Player类作为备用
                tryFallbackPlay(phraseId, btn, originalContent);
                return;
            }
            
            // 音频播放完成后恢复按钮
            setTimeout(() => updateButtonState(btn, false, originalContent), 2000);
        })
        .catch(err => {
            console.error(`播放错误: ${err.message}`);
            // 尝试使用备用播放方式
            tryFallbackPlay(phraseId, btn, originalContent);
        });
}

/**
 * 更新按钮状态
 */
function updateButtonState(btn, isPlaying, originalContent) {
    if (isPlaying) {
        btn.classList.add('playing');
        btn.innerHTML = '<i class="fas fa-volume-up"></i>';
    } else {
        btn.classList.remove('playing');
        btn.innerHTML = originalContent;
    }
}

/**
 * 备用播放方法
 */
function tryFallbackPlay(phraseId, btn, originalContent) {
    // 使用Player类播放音频（备用方案）
    const player = new Player();
    // 尝试使用Google翻译TTS API作为备用
    player.url = `https://translate.google.com/translate_tts?ie=UTF-8&q=${encodeURIComponent(phraseId)}&tl=en&client=tw-ob`;
    
    player.play()
        .then(() => {
            // 音频播放完成后恢复按钮
            setTimeout(() => updateButtonState(btn, false, originalContent), 2000);
        })
        .catch(err => {
            console.error(`备用播放也失败: ${err.message}`);
            // 播放失败时也恢复按钮
            setTimeout(() => updateButtonState(btn, false, originalContent), 2000);
        });
}


// 当页面加载完成时执行
// document.addEventListener('DOMContentLoaded', function() {
//     // 监听场景标签切换，预加载对应场景音频
//     document.querySelectorAll('.nav-tabs a').forEach(tab => {
//         tab.addEventListener('click', function() {
//             const targetId = this.getAttribute('href').substring(1);
//             audioManager.loadCategoryAudios(targetId);
//         });
//     });
    
//     // 默认加载第一个场景的音频
//     const firstTabTarget = document.querySelector('.nav-tabs a.active')?.getAttribute('href');
//     if (firstTabTarget) {
//         audioManager.loadCategoryAudios(firstTabTarget.substring(1));
//     }
// });

// 添加Service Worker注册（用于离线功能）
if ('serviceWorker' in navigator) {
    window.addEventListener('load', () => {
        navigator.serviceWorker.register('sw.js')
            .then(reg => console.log('Service Worker registered'))
            .catch(err => console.log('Service Worker registration failed: ', err));
    });
}